
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">


<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>odespy.RungeKutta &mdash; Odespy API 0.2 documentation</title>
    
    <link rel="stylesheet" href="_static/pyramid.css" type="text/css" />
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
    
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '',
        VERSION:     '0.2',
        COLLAPSE_INDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
      };
    </script>
    <script type="text/javascript" src="_static/jquery.js"></script>
    <script type="text/javascript" src="_static/underscore.js"></script>
    <script type="text/javascript" src="_static/doctools.js"></script>
    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
    <link rel="top" title="Odespy API 0.2 documentation" href="index.html" />
    <link rel="prev" title="odespy.runtests" href="runtests.html" />
<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
<!--[if lte IE 6]>
<link rel="stylesheet" href="_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
<![endif]-->

  </head>
  <body>

    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="np-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="runtests.html" title="odespy.runtests"
             accesskey="P">previous</a> |</li>
        <li><a href="index.html">Odespy API 0.2 documentation</a> &raquo;</li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body">
            
  <div class="section" id="module-odespy.RungeKutta">
<span id="odespy-rungekutta"></span><h1><a class="reference internal" href="#module-odespy.RungeKutta" title="odespy.RungeKutta"><tt class="xref py py-mod docutils literal"><span class="pre">odespy.RungeKutta</span></tt></a><a class="headerlink" href="#module-odespy.RungeKutta" title="Permalink to this headline">¶</a></h1>
<dl class="class">
<dt id="odespy.RungeKutta.BogackiShampine">
<em class="property">class </em><tt class="descclassname">odespy.RungeKutta.</tt><tt class="descname">BogackiShampine</tt><big>(</big><em>f</em>, <em>**kwargs</em><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#BogackiShampine"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.BogackiShampine" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#odespy.RungeKutta.RungeKutta2level" title="odespy.RungeKutta.RungeKutta2level"><tt class="xref py py-class docutils literal"><span class="pre">odespy.RungeKutta.RungeKutta2level</span></tt></a></p>
<p>Adaptive Bogacki-Shampine Runge-Kutta method of order (3, 2).
Implementated in the general Python framework in the RungeKutta module.</p>
<p>Required input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="7%" />
<col width="93%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f</td>
<td>Right-hand side <tt class="docutils literal"><span class="pre">f(u,t)</span></tt> defining the ODE.</td>
</tr>
</tbody>
</table>
<p>Optional input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f_args</td>
<td>Extra positional arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs).</span></tt> (default: ())</td>
</tr>
<tr class="row-odd"><td>f_kwargs</td>
<td>Extra keyword arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs)</span></tt>. (default: {})</td>
</tr>
<tr class="row-even"><td>complex_valued</td>
<td>True if f is complex valued. (default: False)</td>
</tr>
<tr class="row-odd"><td>disk_storage</td>
<td>Indicates whether u is stored in memory or in file. If
string, it is the filename; if False or &#8220;&#8221;, u is kept in
memory; if True, a default filename tmp_odspy.dat is
used. (default: False)</td>
</tr>
<tr class="row-even"><td>verbose</td>
<td>Integer reflecting output of intermediate quantities.
(default: 0)</td>
</tr>
<tr class="row-odd"><td>u_exact</td>
<td>Function of t returning exact solution. (default: None)</td>
</tr>
<tr class="row-even"><td>rtol</td>
<td>Relative tolerance for solution. (default: 1e-06)</td>
</tr>
<tr class="row-odd"><td>atol</td>
<td>Absolute tolerance for solution. (default: 1e-08)</td>
</tr>
<tr class="row-even"><td>first_step</td>
<td>Suggested first time step size for an adaptive
algorithm.</td>
</tr>
<tr class="row-odd"><td>min_step</td>
<td>Minimum step size for an adaptive algorithm.</td>
</tr>
<tr class="row-even"><td>max_step</td>
<td>Maximum step size for an adaptive algorithm.</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">adjust_parameters</span></tt>()</td>
<td>This method allows subclasses to adjust (modify or add) entries in the self._parameters dictionary.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">advance</span></tt>()</td>
<td>Advance from t[n] to t[n+1] in (small) adaptive steps.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_conditional_parameters</span></tt>()</td>
<td>This function is used to check whether conditional parameters are provided when specified condition fulfilled.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_extra</span></tt>(**kwargs)</td>
<td>A parameter may have a keyword <tt class="docutils literal"><span class="pre">extra_check</span></tt> for user-given functions that performs consistency checks on the parameter.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_range</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are in right specified range.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_types</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are of right specified type.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">compile_string_functions</span></tt>(f,&nbsp;**kwargs)</td>
<td>Compile functions which are supplied as Fortran strings.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">constant_time_step</span></tt>()</td>
<td>Check if self.t has a uniform partition.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get</span></tt>([parameter_name,&nbsp;print_info])</td>
<td>Return value of specified input parameters.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_order</span></tt>()</td>
<td>Return the order of current method, both for non-adaptive</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_parameter_info</span></tt>([print_info])</td>
<td>Return a dictionary containing all properties of all legal parameters in current subclass (i.e., the parameters in <tt class="docutils literal"><span class="pre">self._parameters</span></tt>).</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">has_u_t_all</span></tt>()</td>
<td>Return True if self.u_all and self.t_all, defined in</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize</span></tt>()</td>
<td>Subclass-specific initialization.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize_for_solve</span></tt>()</td>
<td></td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">set</span></tt>([strict])</td>
<td>Assign values to one or more parameters, specified as keyword arguments.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">set_initial_condition</span></tt>(U0)</td>
<td>Function set_initial_condition() is used to set initial value of</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">solve</span></tt>(time_points[,&nbsp;terminate])</td>
<td>Compute discrete solution u of the ODE problem at time points</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">switch_to</span></tt>(solver_target[,&nbsp;print_info])</td>
<td>Create a new solver instance which switch to another subclass with same values of common attributes.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">validate_data</span></tt>()</td>
<td>This function is used for extra checking and validating of attributes before the computations start.</td>
</tr>
</tbody>
</table>
<dl class="attribute">
<dt id="odespy.RungeKutta.BogackiShampine.__module__">
<tt class="descname">__module__</tt><em class="property"> = 'odespy.RungeKutta'</em><a class="headerlink" href="#odespy.RungeKutta.BogackiShampine.__module__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="odespy.RungeKutta.BogackiShampine.quick_description">
<tt class="descname">quick_description</tt><em class="property"> = 'Adaptive Bogacki-Shampine RK method of order (3, 2)'</em><a class="headerlink" href="#odespy.RungeKutta.BogackiShampine.quick_description" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="odespy.RungeKutta.CashKarp">
<em class="property">class </em><tt class="descclassname">odespy.RungeKutta.</tt><tt class="descname">CashKarp</tt><big>(</big><em>f</em>, <em>**kwargs</em><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#CashKarp"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.CashKarp" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#odespy.RungeKutta.RungeKutta2level" title="odespy.RungeKutta.RungeKutta2level"><tt class="xref py py-class docutils literal"><span class="pre">odespy.RungeKutta.RungeKutta2level</span></tt></a></p>
<p>Adaptive Cash-Karp Runge-Kutta method of order (5, 4).
Implementated in the general Python framework in the RungeKutta module.</p>
<p>Required input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="7%" />
<col width="93%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f</td>
<td>Right-hand side <tt class="docutils literal"><span class="pre">f(u,t)</span></tt> defining the ODE.</td>
</tr>
</tbody>
</table>
<p>Optional input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f_args</td>
<td>Extra positional arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs).</span></tt> (default: ())</td>
</tr>
<tr class="row-odd"><td>f_kwargs</td>
<td>Extra keyword arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs)</span></tt>. (default: {})</td>
</tr>
<tr class="row-even"><td>complex_valued</td>
<td>True if f is complex valued. (default: False)</td>
</tr>
<tr class="row-odd"><td>disk_storage</td>
<td>Indicates whether u is stored in memory or in file. If
string, it is the filename; if False or &#8220;&#8221;, u is kept in
memory; if True, a default filename tmp_odspy.dat is
used. (default: False)</td>
</tr>
<tr class="row-even"><td>verbose</td>
<td>Integer reflecting output of intermediate quantities.
(default: 0)</td>
</tr>
<tr class="row-odd"><td>u_exact</td>
<td>Function of t returning exact solution. (default: None)</td>
</tr>
<tr class="row-even"><td>rtol</td>
<td>Relative tolerance for solution. (default: 1e-06)</td>
</tr>
<tr class="row-odd"><td>atol</td>
<td>Absolute tolerance for solution. (default: 1e-08)</td>
</tr>
<tr class="row-even"><td>first_step</td>
<td>Suggested first time step size for an adaptive
algorithm.</td>
</tr>
<tr class="row-odd"><td>min_step</td>
<td>Minimum step size for an adaptive algorithm.</td>
</tr>
<tr class="row-even"><td>max_step</td>
<td>Maximum step size for an adaptive algorithm.</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">adjust_parameters</span></tt>()</td>
<td>This method allows subclasses to adjust (modify or add) entries in the self._parameters dictionary.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">advance</span></tt>()</td>
<td>Advance from t[n] to t[n+1] in (small) adaptive steps.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_conditional_parameters</span></tt>()</td>
<td>This function is used to check whether conditional parameters are provided when specified condition fulfilled.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_extra</span></tt>(**kwargs)</td>
<td>A parameter may have a keyword <tt class="docutils literal"><span class="pre">extra_check</span></tt> for user-given functions that performs consistency checks on the parameter.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_range</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are in right specified range.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_types</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are of right specified type.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">compile_string_functions</span></tt>(f,&nbsp;**kwargs)</td>
<td>Compile functions which are supplied as Fortran strings.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">constant_time_step</span></tt>()</td>
<td>Check if self.t has a uniform partition.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get</span></tt>([parameter_name,&nbsp;print_info])</td>
<td>Return value of specified input parameters.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_order</span></tt>()</td>
<td>Return the order of current method, both for non-adaptive</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_parameter_info</span></tt>([print_info])</td>
<td>Return a dictionary containing all properties of all legal parameters in current subclass (i.e., the parameters in <tt class="docutils literal"><span class="pre">self._parameters</span></tt>).</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">has_u_t_all</span></tt>()</td>
<td>Return True if self.u_all and self.t_all, defined in</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize</span></tt>()</td>
<td>Subclass-specific initialization.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize_for_solve</span></tt>()</td>
<td></td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">set</span></tt>([strict])</td>
<td>Assign values to one or more parameters, specified as keyword arguments.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">set_initial_condition</span></tt>(U0)</td>
<td>Function set_initial_condition() is used to set initial value of</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">solve</span></tt>(time_points[,&nbsp;terminate])</td>
<td>Compute discrete solution u of the ODE problem at time points</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">switch_to</span></tt>(solver_target[,&nbsp;print_info])</td>
<td>Create a new solver instance which switch to another subclass with same values of common attributes.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">validate_data</span></tt>()</td>
<td>This function is used for extra checking and validating of attributes before the computations start.</td>
</tr>
</tbody>
</table>
<dl class="attribute">
<dt id="odespy.RungeKutta.CashKarp.__module__">
<tt class="descname">__module__</tt><em class="property"> = 'odespy.RungeKutta'</em><a class="headerlink" href="#odespy.RungeKutta.CashKarp.__module__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="odespy.RungeKutta.CashKarp.quick_description">
<tt class="descname">quick_description</tt><em class="property"> = 'Adaptive Cash-Karp RK method of order (5, 4)'</em><a class="headerlink" href="#odespy.RungeKutta.CashKarp.quick_description" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="odespy.RungeKutta.DormandPrince">
<em class="property">class </em><tt class="descclassname">odespy.RungeKutta.</tt><tt class="descname">DormandPrince</tt><big>(</big><em>f</em>, <em>**kwargs</em><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#DormandPrince"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.DormandPrince" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#odespy.RungeKutta.RungeKutta2level" title="odespy.RungeKutta.RungeKutta2level"><tt class="xref py py-class docutils literal"><span class="pre">odespy.RungeKutta.RungeKutta2level</span></tt></a></p>
<p>Dormand&amp;Prince Runge-Kutta method of order (5, 4).
Implementated in the general Python framework in the RungeKutta module.</p>
<p>Required input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="7%" />
<col width="93%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f</td>
<td>Right-hand side <tt class="docutils literal"><span class="pre">f(u,t)</span></tt> defining the ODE.</td>
</tr>
</tbody>
</table>
<p>Optional input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f_args</td>
<td>Extra positional arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs).</span></tt> (default: ())</td>
</tr>
<tr class="row-odd"><td>f_kwargs</td>
<td>Extra keyword arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs)</span></tt>. (default: {})</td>
</tr>
<tr class="row-even"><td>complex_valued</td>
<td>True if f is complex valued. (default: False)</td>
</tr>
<tr class="row-odd"><td>disk_storage</td>
<td>Indicates whether u is stored in memory or in file. If
string, it is the filename; if False or &#8220;&#8221;, u is kept in
memory; if True, a default filename tmp_odspy.dat is
used. (default: False)</td>
</tr>
<tr class="row-even"><td>verbose</td>
<td>Integer reflecting output of intermediate quantities.
(default: 0)</td>
</tr>
<tr class="row-odd"><td>u_exact</td>
<td>Function of t returning exact solution. (default: None)</td>
</tr>
<tr class="row-even"><td>rtol</td>
<td>Relative tolerance for solution. (default: 1e-06)</td>
</tr>
<tr class="row-odd"><td>atol</td>
<td>Absolute tolerance for solution. (default: 1e-08)</td>
</tr>
<tr class="row-even"><td>first_step</td>
<td>Suggested first time step size for an adaptive
algorithm.</td>
</tr>
<tr class="row-odd"><td>min_step</td>
<td>Minimum step size for an adaptive algorithm.</td>
</tr>
<tr class="row-even"><td>max_step</td>
<td>Maximum step size for an adaptive algorithm.</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">adjust_parameters</span></tt>()</td>
<td>This method allows subclasses to adjust (modify or add) entries in the self._parameters dictionary.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">advance</span></tt>()</td>
<td>Advance from t[n] to t[n+1] in (small) adaptive steps.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_conditional_parameters</span></tt>()</td>
<td>This function is used to check whether conditional parameters are provided when specified condition fulfilled.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_extra</span></tt>(**kwargs)</td>
<td>A parameter may have a keyword <tt class="docutils literal"><span class="pre">extra_check</span></tt> for user-given functions that performs consistency checks on the parameter.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_range</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are in right specified range.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_types</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are of right specified type.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">compile_string_functions</span></tt>(f,&nbsp;**kwargs)</td>
<td>Compile functions which are supplied as Fortran strings.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">constant_time_step</span></tt>()</td>
<td>Check if self.t has a uniform partition.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get</span></tt>([parameter_name,&nbsp;print_info])</td>
<td>Return value of specified input parameters.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_order</span></tt>()</td>
<td>Return the order of current method, both for non-adaptive</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_parameter_info</span></tt>([print_info])</td>
<td>Return a dictionary containing all properties of all legal parameters in current subclass (i.e., the parameters in <tt class="docutils literal"><span class="pre">self._parameters</span></tt>).</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">has_u_t_all</span></tt>()</td>
<td>Return True if self.u_all and self.t_all, defined in</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize</span></tt>()</td>
<td>Subclass-specific initialization.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize_for_solve</span></tt>()</td>
<td></td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">set</span></tt>([strict])</td>
<td>Assign values to one or more parameters, specified as keyword arguments.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">set_initial_condition</span></tt>(U0)</td>
<td>Function set_initial_condition() is used to set initial value of</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">solve</span></tt>(time_points[,&nbsp;terminate])</td>
<td>Compute discrete solution u of the ODE problem at time points</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">switch_to</span></tt>(solver_target[,&nbsp;print_info])</td>
<td>Create a new solver instance which switch to another subclass with same values of common attributes.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">validate_data</span></tt>()</td>
<td>This function is used for extra checking and validating of attributes before the computations start.</td>
</tr>
</tbody>
</table>
<dl class="attribute">
<dt id="odespy.RungeKutta.DormandPrince.__module__">
<tt class="descname">__module__</tt><em class="property"> = 'odespy.RungeKutta'</em><a class="headerlink" href="#odespy.RungeKutta.DormandPrince.__module__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="odespy.RungeKutta.DormandPrince.quick_description">
<tt class="descname">quick_description</tt><em class="property"> = 'Dormand &amp; Prince RK method of order (5, 4)'</em><a class="headerlink" href="#odespy.RungeKutta.DormandPrince.quick_description" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="odespy.RungeKutta.Fehlberg">
<em class="property">class </em><tt class="descclassname">odespy.RungeKutta.</tt><tt class="descname">Fehlberg</tt><big>(</big><em>f</em>, <em>**kwargs</em><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#Fehlberg"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.Fehlberg" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#odespy.RungeKutta.RungeKutta2level" title="odespy.RungeKutta.RungeKutta2level"><tt class="xref py py-class docutils literal"><span class="pre">odespy.RungeKutta.RungeKutta2level</span></tt></a></p>
<p>Adaptive Runge-Kutta-Fehlberg method of order (4, 5).
Implementated in the general Python framework in the RungeKutta module.</p>
<p>Required input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="7%" />
<col width="93%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f</td>
<td>Right-hand side <tt class="docutils literal"><span class="pre">f(u,t)</span></tt> defining the ODE.</td>
</tr>
</tbody>
</table>
<p>Optional input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f_args</td>
<td>Extra positional arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs).</span></tt> (default: ())</td>
</tr>
<tr class="row-odd"><td>f_kwargs</td>
<td>Extra keyword arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs)</span></tt>. (default: {})</td>
</tr>
<tr class="row-even"><td>complex_valued</td>
<td>True if f is complex valued. (default: False)</td>
</tr>
<tr class="row-odd"><td>disk_storage</td>
<td>Indicates whether u is stored in memory or in file. If
string, it is the filename; if False or &#8220;&#8221;, u is kept in
memory; if True, a default filename tmp_odspy.dat is
used. (default: False)</td>
</tr>
<tr class="row-even"><td>verbose</td>
<td>Integer reflecting output of intermediate quantities.
(default: 0)</td>
</tr>
<tr class="row-odd"><td>u_exact</td>
<td>Function of t returning exact solution. (default: None)</td>
</tr>
<tr class="row-even"><td>rtol</td>
<td>Relative tolerance for solution. (default: 1e-06)</td>
</tr>
<tr class="row-odd"><td>atol</td>
<td>Absolute tolerance for solution. (default: 1e-08)</td>
</tr>
<tr class="row-even"><td>first_step</td>
<td>Suggested first time step size for an adaptive
algorithm.</td>
</tr>
<tr class="row-odd"><td>min_step</td>
<td>Minimum step size for an adaptive algorithm.</td>
</tr>
<tr class="row-even"><td>max_step</td>
<td>Maximum step size for an adaptive algorithm.</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">adjust_parameters</span></tt>()</td>
<td>This method allows subclasses to adjust (modify or add) entries in the self._parameters dictionary.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">advance</span></tt>()</td>
<td>Advance from t[n] to t[n+1] in (small) adaptive steps.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_conditional_parameters</span></tt>()</td>
<td>This function is used to check whether conditional parameters are provided when specified condition fulfilled.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_extra</span></tt>(**kwargs)</td>
<td>A parameter may have a keyword <tt class="docutils literal"><span class="pre">extra_check</span></tt> for user-given functions that performs consistency checks on the parameter.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_range</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are in right specified range.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_types</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are of right specified type.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">compile_string_functions</span></tt>(f,&nbsp;**kwargs)</td>
<td>Compile functions which are supplied as Fortran strings.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">constant_time_step</span></tt>()</td>
<td>Check if self.t has a uniform partition.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get</span></tt>([parameter_name,&nbsp;print_info])</td>
<td>Return value of specified input parameters.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_order</span></tt>()</td>
<td>Return the order of current method, both for non-adaptive</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_parameter_info</span></tt>([print_info])</td>
<td>Return a dictionary containing all properties of all legal parameters in current subclass (i.e., the parameters in <tt class="docutils literal"><span class="pre">self._parameters</span></tt>).</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">has_u_t_all</span></tt>()</td>
<td>Return True if self.u_all and self.t_all, defined in</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize</span></tt>()</td>
<td>Subclass-specific initialization.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize_for_solve</span></tt>()</td>
<td></td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">set</span></tt>([strict])</td>
<td>Assign values to one or more parameters, specified as keyword arguments.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">set_initial_condition</span></tt>(U0)</td>
<td>Function set_initial_condition() is used to set initial value of</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">solve</span></tt>(time_points[,&nbsp;terminate])</td>
<td>Compute discrete solution u of the ODE problem at time points</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">switch_to</span></tt>(solver_target[,&nbsp;print_info])</td>
<td>Create a new solver instance which switch to another subclass with same values of common attributes.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">validate_data</span></tt>()</td>
<td>This function is used for extra checking and validating of attributes before the computations start.</td>
</tr>
</tbody>
</table>
<dl class="attribute">
<dt id="odespy.RungeKutta.Fehlberg.__module__">
<tt class="descname">__module__</tt><em class="property"> = 'odespy.RungeKutta'</em><a class="headerlink" href="#odespy.RungeKutta.Fehlberg.__module__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="odespy.RungeKutta.Fehlberg.quick_description">
<tt class="descname">quick_description</tt><em class="property"> = 'Adaptive Runge-Kutta-Fehlberg (4,5) method'</em><a class="headerlink" href="#odespy.RungeKutta.Fehlberg.quick_description" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="odespy.RungeKutta.MyRungeKutta">
<em class="property">class </em><tt class="descclassname">odespy.RungeKutta.</tt><tt class="descname">MyRungeKutta</tt><big>(</big><em>f</em>, <em>**kwargs</em><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#MyRungeKutta"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.MyRungeKutta" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#odespy.RungeKutta.RungeKutta2level" title="odespy.RungeKutta.RungeKutta2level"><tt class="xref py py-class docutils literal"><span class="pre">odespy.RungeKutta.RungeKutta2level</span></tt></a></p>
<p>User-supplied RungeKutta method, which is defined by providing
butcher-table in an 2d-array.
Method order should be provided if it is known. If not, the order
would be estimated automatically with function get_order().</p>
<p>Required input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="23%" />
<col width="77%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f</td>
<td>Right-hand side <tt class="docutils literal"><span class="pre">f(u,t)</span></tt> defining the ODE.</td>
</tr>
<tr class="row-odd"><td>butcher_tableau</td>
<td>2d-array which contains the butcher table for user-
supplied Runge-Kutta method. (n,n) array for 1-level
Runge-Kutta methods.(n+1,n) array for 2-level Runge-
Kutta methods.</td>
</tr>
</tbody>
</table>
<p>Optional input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f_args</td>
<td>Extra positional arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs).</span></tt> (default: ())</td>
</tr>
<tr class="row-odd"><td>f_kwargs</td>
<td>Extra keyword arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs)</span></tt>. (default: {})</td>
</tr>
<tr class="row-even"><td>complex_valued</td>
<td>True if f is complex valued. (default: False)</td>
</tr>
<tr class="row-odd"><td>disk_storage</td>
<td>Indicates whether u is stored in memory or in file. If
string, it is the filename; if False or &#8220;&#8221;, u is kept in
memory; if True, a default filename tmp_odspy.dat is
used. (default: False)</td>
</tr>
<tr class="row-even"><td>verbose</td>
<td>Integer reflecting output of intermediate quantities.
(default: 0)</td>
</tr>
<tr class="row-odd"><td>u_exact</td>
<td>Function of t returning exact solution. (default: None)</td>
</tr>
<tr class="row-even"><td>rtol</td>
<td>Relative tolerance for solution. (default: 1e-06)</td>
</tr>
<tr class="row-odd"><td>atol</td>
<td>Absolute tolerance for solution. (default: 1e-08)</td>
</tr>
<tr class="row-even"><td>first_step</td>
<td>Suggested first time step size for an adaptive
algorithm.</td>
</tr>
<tr class="row-odd"><td>min_step</td>
<td>Minimum step size for an adaptive algorithm.</td>
</tr>
<tr class="row-even"><td>max_step</td>
<td>Maximum step size for an adaptive algorithm.</td>
</tr>
<tr class="row-odd"><td>method_order</td>
<td>Method order for user-defined method if known.A integer
for 1-level methods, or a pair of   integer for 2-levels
methods.</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">adjust_parameters</span></tt>()</td>
<td>This method allows subclasses to adjust (modify or add) entries in the self._parameters dictionary.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">advance</span></tt>()</td>
<td>Advance from t[n] to t[n+1] in (small) adaptive steps.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_conditional_parameters</span></tt>()</td>
<td>This function is used to check whether conditional parameters are provided when specified condition fulfilled.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_extra</span></tt>(**kwargs)</td>
<td>A parameter may have a keyword <tt class="docutils literal"><span class="pre">extra_check</span></tt> for user-given functions that performs consistency checks on the parameter.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_range</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are in right specified range.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_types</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are of right specified type.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">compile_string_functions</span></tt>(f,&nbsp;**kwargs)</td>
<td>Compile functions which are supplied as Fortran strings.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">constant_time_step</span></tt>()</td>
<td>Check if self.t has a uniform partition.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get</span></tt>([parameter_name,&nbsp;print_info])</td>
<td>Return value of specified input parameters.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_order</span></tt>()</td>
<td>Return the order of current method, both for non-adaptive</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_parameter_info</span></tt>([print_info])</td>
<td>Return a dictionary containing all properties of all legal parameters in current subclass (i.e., the parameters in <tt class="docutils literal"><span class="pre">self._parameters</span></tt>).</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">has_u_t_all</span></tt>()</td>
<td>Return True if self.u_all and self.t_all, defined in</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize</span></tt>()</td>
<td>Subclass-specific initialization.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize_for_solve</span></tt>()</td>
<td></td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">set</span></tt>([strict])</td>
<td>Assign values to one or more parameters, specified as keyword arguments.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">set_initial_condition</span></tt>(U0)</td>
<td>Function set_initial_condition() is used to set initial value of</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">solve</span></tt>(time_points[,&nbsp;terminate])</td>
<td>Compute discrete solution u of the ODE problem at time points</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">switch_to</span></tt>(solver_target[,&nbsp;print_info])</td>
<td>Create a new solver instance which switch to another subclass with same values of common attributes.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#odespy.RungeKutta.MyRungeKutta.validate_data" title="odespy.RungeKutta.MyRungeKutta.validate_data"><tt class="xref py py-obj docutils literal"><span class="pre">validate_data</span></tt></a>()</td>
<td></td>
</tr>
</tbody>
</table>
<dl class="attribute">
<dt id="odespy.RungeKutta.MyRungeKutta.__module__">
<tt class="descname">__module__</tt><em class="property"> = 'odespy.RungeKutta'</em><a class="headerlink" href="#odespy.RungeKutta.MyRungeKutta.__module__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="odespy.RungeKutta.MyRungeKutta.validate_data">
<tt class="descname">validate_data</tt><big>(</big><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#MyRungeKutta.validate_data"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.MyRungeKutta.validate_data" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="odespy.RungeKutta.RungeKutta1">
<em class="property">class </em><tt class="descclassname">odespy.RungeKutta.</tt><tt class="descname">RungeKutta1</tt><big>(</big><em>f</em>, <em>**kwargs</em><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#RungeKutta1"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.RungeKutta1" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#odespy.RungeKutta.RungeKutta1level" title="odespy.RungeKutta.RungeKutta1level"><tt class="xref py py-class docutils literal"><span class="pre">odespy.RungeKutta.RungeKutta1level</span></tt></a></p>
<p>Explicit Forward Euler method implemented
in the general RungeKutta Python framework.</p>
<p>Required input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="7%" />
<col width="93%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f</td>
<td>Right-hand side <tt class="docutils literal"><span class="pre">f(u,t)</span></tt> defining the ODE.</td>
</tr>
</tbody>
</table>
<p>Optional input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f_args</td>
<td>Extra positional arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs).</span></tt> (default: ())</td>
</tr>
<tr class="row-odd"><td>f_kwargs</td>
<td>Extra keyword arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs)</span></tt>. (default: {})</td>
</tr>
<tr class="row-even"><td>complex_valued</td>
<td>True if f is complex valued. (default: False)</td>
</tr>
<tr class="row-odd"><td>disk_storage</td>
<td>Indicates whether u is stored in memory or in file. If
string, it is the filename; if False or &#8220;&#8221;, u is kept in
memory; if True, a default filename tmp_odspy.dat is
used. (default: False)</td>
</tr>
<tr class="row-even"><td>verbose</td>
<td>Integer reflecting output of intermediate quantities.
(default: 0)</td>
</tr>
<tr class="row-odd"><td>u_exact</td>
<td>Function of t returning exact solution. (default: None)</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">adjust_parameters</span></tt>()</td>
<td>This method allows subclasses to adjust (modify or add) entries in the self._parameters dictionary.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">advance</span></tt>()</td>
<td>Advance the solution one time step: t[n] to t[n+1].</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_conditional_parameters</span></tt>()</td>
<td>This function is used to check whether conditional parameters are provided when specified condition fulfilled.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_extra</span></tt>(**kwargs)</td>
<td>A parameter may have a keyword <tt class="docutils literal"><span class="pre">extra_check</span></tt> for user-given functions that performs consistency checks on the parameter.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_range</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are in right specified range.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_types</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are of right specified type.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">compile_string_functions</span></tt>(f,&nbsp;**kwargs)</td>
<td>Compile functions which are supplied as Fortran strings.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">constant_time_step</span></tt>()</td>
<td>Check if self.t has a uniform partition.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get</span></tt>([parameter_name,&nbsp;print_info])</td>
<td>Return value of specified input parameters.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_order</span></tt>()</td>
<td>Return the order of the current method.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_parameter_info</span></tt>([print_info])</td>
<td>Return a dictionary containing all properties of all legal parameters in current subclass (i.e., the parameters in <tt class="docutils literal"><span class="pre">self._parameters</span></tt>).</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">has_u_t_all</span></tt>()</td>
<td>Return True if self.u_all and self.t_all, defined in</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize</span></tt>()</td>
<td>Subclass-specific initialization.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize_for_solve</span></tt>()</td>
<td>Setting values of internal attributes to be used in iteration.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">set</span></tt>([strict])</td>
<td>Assign values to one or more parameters, specified as keyword arguments.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">set_initial_condition</span></tt>(U0)</td>
<td>Function set_initial_condition() is used to set initial value of</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">solve</span></tt>(time_points[,&nbsp;terminate])</td>
<td>Compute discrete solution u of the ODE problem at time points</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">switch_to</span></tt>(solver_target[,&nbsp;print_info])</td>
<td>Create a new solver instance which switch to another subclass with same values of common attributes.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">validate_data</span></tt>()</td>
<td>This function is used for extra checking and validating of attributes before the computations start.</td>
</tr>
</tbody>
</table>
<dl class="attribute">
<dt id="odespy.RungeKutta.RungeKutta1.__module__">
<tt class="descname">__module__</tt><em class="property"> = 'odespy.RungeKutta'</em><a class="headerlink" href="#odespy.RungeKutta.RungeKutta1.__module__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="odespy.RungeKutta.RungeKutta1.quick_description">
<tt class="descname">quick_description</tt><em class="property"> = 'Explicit 1st-order Runge-Kutta method'</em><a class="headerlink" href="#odespy.RungeKutta.RungeKutta1.quick_description" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="odespy.RungeKutta.RungeKutta1level">
<em class="property">class </em><tt class="descclassname">odespy.RungeKutta.</tt><tt class="descname">RungeKutta1level</tt><big>(</big><em>f</em>, <em>**kwargs</em><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#RungeKutta1level"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.RungeKutta1level" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="solvers.html#odespy.solvers.Solver" title="odespy.solvers.Solver"><tt class="xref py py-class docutils literal"><span class="pre">odespy.solvers.Solver</span></tt></a></p>
<p>Superclass for explicit 1-level Runge-Kutta methods.  Subclasses
are RungeKutta4, Rungekutta2, RungeKutta3, RugeKutta1 (Forward
Euler).</p>
<p>Required input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="7%" />
<col width="93%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f</td>
<td>Right-hand side <tt class="docutils literal"><span class="pre">f(u,t)</span></tt> defining the ODE.</td>
</tr>
</tbody>
</table>
<p>Optional input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f_args</td>
<td>Extra positional arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs).</span></tt> (default: ())</td>
</tr>
<tr class="row-odd"><td>f_kwargs</td>
<td>Extra keyword arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs)</span></tt>. (default: {})</td>
</tr>
<tr class="row-even"><td>complex_valued</td>
<td>True if f is complex valued. (default: False)</td>
</tr>
<tr class="row-odd"><td>disk_storage</td>
<td>Indicates whether u is stored in memory or in file. If
string, it is the filename; if False or &#8220;&#8221;, u is kept in
memory; if True, a default filename tmp_odspy.dat is
used. (default: False)</td>
</tr>
<tr class="row-even"><td>verbose</td>
<td>Integer reflecting output of intermediate quantities.
(default: 0)</td>
</tr>
<tr class="row-odd"><td>u_exact</td>
<td>Function of t returning exact solution. (default: None)</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">adjust_parameters</span></tt>()</td>
<td>This method allows subclasses to adjust (modify or add) entries in the self._parameters dictionary.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#odespy.RungeKutta.RungeKutta1level.advance" title="odespy.RungeKutta.RungeKutta1level.advance"><tt class="xref py py-obj docutils literal"><span class="pre">advance</span></tt></a>()</td>
<td>Advance the solution one time step: t[n] to t[n+1].</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_conditional_parameters</span></tt>()</td>
<td>This function is used to check whether conditional parameters are provided when specified condition fulfilled.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_extra</span></tt>(**kwargs)</td>
<td>A parameter may have a keyword <tt class="docutils literal"><span class="pre">extra_check</span></tt> for user-given functions that performs consistency checks on the parameter.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_range</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are in right specified range.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_types</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are of right specified type.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">compile_string_functions</span></tt>(f,&nbsp;**kwargs)</td>
<td>Compile functions which are supplied as Fortran strings.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">constant_time_step</span></tt>()</td>
<td>Check if self.t has a uniform partition.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get</span></tt>([parameter_name,&nbsp;print_info])</td>
<td>Return value of specified input parameters.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#odespy.RungeKutta.RungeKutta1level.get_order" title="odespy.RungeKutta.RungeKutta1level.get_order"><tt class="xref py py-obj docutils literal"><span class="pre">get_order</span></tt></a>()</td>
<td>Return the order of the current method.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_parameter_info</span></tt>([print_info])</td>
<td>Return a dictionary containing all properties of all legal parameters in current subclass (i.e., the parameters in <tt class="docutils literal"><span class="pre">self._parameters</span></tt>).</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">has_u_t_all</span></tt>()</td>
<td>Return True if self.u_all and self.t_all, defined in</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize</span></tt>()</td>
<td>Subclass-specific initialization.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize_for_solve</span></tt>()</td>
<td>Setting values of internal attributes to be used in iteration.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">set</span></tt>([strict])</td>
<td>Assign values to one or more parameters, specified as keyword arguments.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">set_initial_condition</span></tt>(U0)</td>
<td>Function set_initial_condition() is used to set initial value of</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">solve</span></tt>(time_points[,&nbsp;terminate])</td>
<td>Compute discrete solution u of the ODE problem at time points</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">switch_to</span></tt>(solver_target[,&nbsp;print_info])</td>
<td>Create a new solver instance which switch to another subclass with same values of common attributes.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">validate_data</span></tt>()</td>
<td>This function is used for extra checking and validating of attributes before the computations start.</td>
</tr>
</tbody>
</table>
<dl class="attribute">
<dt id="odespy.RungeKutta.RungeKutta1level.__module__">
<tt class="descname">__module__</tt><em class="property"> = 'odespy.RungeKutta'</em><a class="headerlink" href="#odespy.RungeKutta.RungeKutta1level.__module__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="odespy.RungeKutta.RungeKutta1level.advance">
<tt class="descname">advance</tt><big>(</big><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#RungeKutta1level.advance"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.RungeKutta1level.advance" title="Permalink to this definition">¶</a></dt>
<dd><p>Advance the solution one time step: t[n] to t[n+1].</p>
</dd></dl>

<dl class="method">
<dt id="odespy.RungeKutta.RungeKutta1level.get_order">
<tt class="descname">get_order</tt><big>(</big><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#RungeKutta1level.get_order"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.RungeKutta1level.get_order" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the order of the current method.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="odespy.RungeKutta.RungeKutta2">
<em class="property">class </em><tt class="descclassname">odespy.RungeKutta.</tt><tt class="descname">RungeKutta2</tt><big>(</big><em>f</em>, <em>**kwargs</em><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#RungeKutta2"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.RungeKutta2" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#odespy.RungeKutta.RungeKutta1level" title="odespy.RungeKutta.RungeKutta1level"><tt class="xref py py-class docutils literal"><span class="pre">odespy.RungeKutta.RungeKutta1level</span></tt></a></p>
<p>Standard Runge-Kutta method of order 2.
Implementated in the general Python framework in the RungeKutta module.</p>
<p>Required input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="7%" />
<col width="93%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f</td>
<td>Right-hand side <tt class="docutils literal"><span class="pre">f(u,t)</span></tt> defining the ODE.</td>
</tr>
</tbody>
</table>
<p>Optional input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f_args</td>
<td>Extra positional arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs).</span></tt> (default: ())</td>
</tr>
<tr class="row-odd"><td>f_kwargs</td>
<td>Extra keyword arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs)</span></tt>. (default: {})</td>
</tr>
<tr class="row-even"><td>complex_valued</td>
<td>True if f is complex valued. (default: False)</td>
</tr>
<tr class="row-odd"><td>disk_storage</td>
<td>Indicates whether u is stored in memory or in file. If
string, it is the filename; if False or &#8220;&#8221;, u is kept in
memory; if True, a default filename tmp_odspy.dat is
used. (default: False)</td>
</tr>
<tr class="row-even"><td>verbose</td>
<td>Integer reflecting output of intermediate quantities.
(default: 0)</td>
</tr>
<tr class="row-odd"><td>u_exact</td>
<td>Function of t returning exact solution. (default: None)</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">adjust_parameters</span></tt>()</td>
<td>This method allows subclasses to adjust (modify or add) entries in the self._parameters dictionary.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">advance</span></tt>()</td>
<td>Advance the solution one time step: t[n] to t[n+1].</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_conditional_parameters</span></tt>()</td>
<td>This function is used to check whether conditional parameters are provided when specified condition fulfilled.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_extra</span></tt>(**kwargs)</td>
<td>A parameter may have a keyword <tt class="docutils literal"><span class="pre">extra_check</span></tt> for user-given functions that performs consistency checks on the parameter.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_range</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are in right specified range.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_types</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are of right specified type.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">compile_string_functions</span></tt>(f,&nbsp;**kwargs)</td>
<td>Compile functions which are supplied as Fortran strings.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">constant_time_step</span></tt>()</td>
<td>Check if self.t has a uniform partition.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get</span></tt>([parameter_name,&nbsp;print_info])</td>
<td>Return value of specified input parameters.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_order</span></tt>()</td>
<td>Return the order of the current method.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_parameter_info</span></tt>([print_info])</td>
<td>Return a dictionary containing all properties of all legal parameters in current subclass (i.e., the parameters in <tt class="docutils literal"><span class="pre">self._parameters</span></tt>).</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">has_u_t_all</span></tt>()</td>
<td>Return True if self.u_all and self.t_all, defined in</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize</span></tt>()</td>
<td>Subclass-specific initialization.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize_for_solve</span></tt>()</td>
<td>Setting values of internal attributes to be used in iteration.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">set</span></tt>([strict])</td>
<td>Assign values to one or more parameters, specified as keyword arguments.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">set_initial_condition</span></tt>(U0)</td>
<td>Function set_initial_condition() is used to set initial value of</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">solve</span></tt>(time_points[,&nbsp;terminate])</td>
<td>Compute discrete solution u of the ODE problem at time points</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">switch_to</span></tt>(solver_target[,&nbsp;print_info])</td>
<td>Create a new solver instance which switch to another subclass with same values of common attributes.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">validate_data</span></tt>()</td>
<td>This function is used for extra checking and validating of attributes before the computations start.</td>
</tr>
</tbody>
</table>
<dl class="attribute">
<dt id="odespy.RungeKutta.RungeKutta2.__module__">
<tt class="descname">__module__</tt><em class="property"> = 'odespy.RungeKutta'</em><a class="headerlink" href="#odespy.RungeKutta.RungeKutta2.__module__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="odespy.RungeKutta.RungeKutta2.quick_description">
<tt class="descname">quick_description</tt><em class="property"> = 'Explicit 2nd-order Runge-Kutta method'</em><a class="headerlink" href="#odespy.RungeKutta.RungeKutta2.quick_description" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="odespy.RungeKutta.RungeKutta2level">
<em class="property">class </em><tt class="descclassname">odespy.RungeKutta.</tt><tt class="descname">RungeKutta2level</tt><big>(</big><em>f</em>, <em>**kwargs</em><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#RungeKutta2level"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.RungeKutta2level" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="solvers.html#odespy.solvers.Adaptive" title="odespy.solvers.Adaptive"><tt class="xref py py-class docutils literal"><span class="pre">odespy.solvers.Adaptive</span></tt></a></p>
<p>Superclass for 2-levels adaptive Runge-Kutta methods:
DormandPrince, Fehlberg, CashKarp, BogackiShampine,
MyRungeKutta (user-supplied RungeKutta methods).</p>
<p>NOTE: This class should be superclass for level-1 methods.
A subclass AdaptiveRungeKutta can act as superclass for
the level-2 methods. get_order can be in RungeKutta.</p>
<p>Required input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="7%" />
<col width="93%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f</td>
<td>Right-hand side <tt class="docutils literal"><span class="pre">f(u,t)</span></tt> defining the ODE.</td>
</tr>
</tbody>
</table>
<p>Optional input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f_args</td>
<td>Extra positional arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs).</span></tt> (default: ())</td>
</tr>
<tr class="row-odd"><td>f_kwargs</td>
<td>Extra keyword arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs)</span></tt>. (default: {})</td>
</tr>
<tr class="row-even"><td>complex_valued</td>
<td>True if f is complex valued. (default: False)</td>
</tr>
<tr class="row-odd"><td>disk_storage</td>
<td>Indicates whether u is stored in memory or in file. If
string, it is the filename; if False or &#8220;&#8221;, u is kept in
memory; if True, a default filename tmp_odspy.dat is
used. (default: False)</td>
</tr>
<tr class="row-even"><td>verbose</td>
<td>Integer reflecting output of intermediate quantities.
(default: 0)</td>
</tr>
<tr class="row-odd"><td>u_exact</td>
<td>Function of t returning exact solution. (default: None)</td>
</tr>
<tr class="row-even"><td>rtol</td>
<td>Relative tolerance for solution. (default: 1e-06)</td>
</tr>
<tr class="row-odd"><td>atol</td>
<td>Absolute tolerance for solution. (default: 1e-08)</td>
</tr>
<tr class="row-even"><td>first_step</td>
<td>Suggested first time step size for an adaptive
algorithm.</td>
</tr>
<tr class="row-odd"><td>min_step</td>
<td>Minimum step size for an adaptive algorithm.</td>
</tr>
<tr class="row-even"><td>max_step</td>
<td>Maximum step size for an adaptive algorithm.</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">adjust_parameters</span></tt>()</td>
<td>This method allows subclasses to adjust (modify or add) entries in the self._parameters dictionary.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#odespy.RungeKutta.RungeKutta2level.advance" title="odespy.RungeKutta.RungeKutta2level.advance"><tt class="xref py py-obj docutils literal"><span class="pre">advance</span></tt></a>()</td>
<td>Advance from t[n] to t[n+1] in (small) adaptive steps.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_conditional_parameters</span></tt>()</td>
<td>This function is used to check whether conditional parameters are provided when specified condition fulfilled.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_extra</span></tt>(**kwargs)</td>
<td>A parameter may have a keyword <tt class="docutils literal"><span class="pre">extra_check</span></tt> for user-given functions that performs consistency checks on the parameter.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_range</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are in right specified range.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_types</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are of right specified type.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">compile_string_functions</span></tt>(f,&nbsp;**kwargs)</td>
<td>Compile functions which are supplied as Fortran strings.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">constant_time_step</span></tt>()</td>
<td>Check if self.t has a uniform partition.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get</span></tt>([parameter_name,&nbsp;print_info])</td>
<td>Return value of specified input parameters.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#odespy.RungeKutta.RungeKutta2level.get_order" title="odespy.RungeKutta.RungeKutta2level.get_order"><tt class="xref py py-obj docutils literal"><span class="pre">get_order</span></tt></a>()</td>
<td>Return the order of current method, both for non-adaptive</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_parameter_info</span></tt>([print_info])</td>
<td>Return a dictionary containing all properties of all legal parameters in current subclass (i.e., the parameters in <tt class="docutils literal"><span class="pre">self._parameters</span></tt>).</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">has_u_t_all</span></tt>()</td>
<td>Return True if self.u_all and self.t_all, defined in</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize</span></tt>()</td>
<td>Subclass-specific initialization.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#odespy.RungeKutta.RungeKutta2level.initialize_for_solve" title="odespy.RungeKutta.RungeKutta2level.initialize_for_solve"><tt class="xref py py-obj docutils literal"><span class="pre">initialize_for_solve</span></tt></a>()</td>
<td></td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">set</span></tt>([strict])</td>
<td>Assign values to one or more parameters, specified as keyword arguments.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">set_initial_condition</span></tt>(U0)</td>
<td>Function set_initial_condition() is used to set initial value of</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">solve</span></tt>(time_points[,&nbsp;terminate])</td>
<td>Compute discrete solution u of the ODE problem at time points</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">switch_to</span></tt>(solver_target[,&nbsp;print_info])</td>
<td>Create a new solver instance which switch to another subclass with same values of common attributes.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">validate_data</span></tt>()</td>
<td>This function is used for extra checking and validating of attributes before the computations start.</td>
</tr>
</tbody>
</table>
<dl class="attribute">
<dt id="odespy.RungeKutta.RungeKutta2level.__module__">
<tt class="descname">__module__</tt><em class="property"> = 'odespy.RungeKutta'</em><a class="headerlink" href="#odespy.RungeKutta.RungeKutta2level.__module__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="odespy.RungeKutta.RungeKutta2level.advance">
<tt class="descname">advance</tt><big>(</big><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#RungeKutta2level.advance"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.RungeKutta2level.advance" title="Permalink to this definition">¶</a></dt>
<dd><p>Advance from t[n] to t[n+1] in (small) adaptive steps.</p>
</dd></dl>

<dl class="method">
<dt id="odespy.RungeKutta.RungeKutta2level.get_order">
<tt class="descname">get_order</tt><big>(</big><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#RungeKutta2level.get_order"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.RungeKutta2level.get_order" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the order of current method, both for non-adaptive
and adaptive methods.</p>
</dd></dl>

<dl class="method">
<dt id="odespy.RungeKutta.RungeKutta2level.initialize_for_solve">
<tt class="descname">initialize_for_solve</tt><big>(</big><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#RungeKutta2level.initialize_for_solve"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.RungeKutta2level.initialize_for_solve" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="odespy.RungeKutta.RungeKutta3">
<em class="property">class </em><tt class="descclassname">odespy.RungeKutta.</tt><tt class="descname">RungeKutta3</tt><big>(</big><em>f</em>, <em>**kwargs</em><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#RungeKutta3"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.RungeKutta3" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#odespy.RungeKutta.RungeKutta1level" title="odespy.RungeKutta.RungeKutta1level"><tt class="xref py py-class docutils literal"><span class="pre">odespy.RungeKutta.RungeKutta1level</span></tt></a></p>
<p>Standard Runge-Kutta method of order 3.
Implementated in the general Python framework in the RungeKutta module.</p>
<p>Required input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="7%" />
<col width="93%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f</td>
<td>Right-hand side <tt class="docutils literal"><span class="pre">f(u,t)</span></tt> defining the ODE.</td>
</tr>
</tbody>
</table>
<p>Optional input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f_args</td>
<td>Extra positional arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs).</span></tt> (default: ())</td>
</tr>
<tr class="row-odd"><td>f_kwargs</td>
<td>Extra keyword arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs)</span></tt>. (default: {})</td>
</tr>
<tr class="row-even"><td>complex_valued</td>
<td>True if f is complex valued. (default: False)</td>
</tr>
<tr class="row-odd"><td>disk_storage</td>
<td>Indicates whether u is stored in memory or in file. If
string, it is the filename; if False or &#8220;&#8221;, u is kept in
memory; if True, a default filename tmp_odspy.dat is
used. (default: False)</td>
</tr>
<tr class="row-even"><td>verbose</td>
<td>Integer reflecting output of intermediate quantities.
(default: 0)</td>
</tr>
<tr class="row-odd"><td>u_exact</td>
<td>Function of t returning exact solution. (default: None)</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">adjust_parameters</span></tt>()</td>
<td>This method allows subclasses to adjust (modify or add) entries in the self._parameters dictionary.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">advance</span></tt>()</td>
<td>Advance the solution one time step: t[n] to t[n+1].</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_conditional_parameters</span></tt>()</td>
<td>This function is used to check whether conditional parameters are provided when specified condition fulfilled.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_extra</span></tt>(**kwargs)</td>
<td>A parameter may have a keyword <tt class="docutils literal"><span class="pre">extra_check</span></tt> for user-given functions that performs consistency checks on the parameter.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_range</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are in right specified range.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_types</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are of right specified type.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">compile_string_functions</span></tt>(f,&nbsp;**kwargs)</td>
<td>Compile functions which are supplied as Fortran strings.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">constant_time_step</span></tt>()</td>
<td>Check if self.t has a uniform partition.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get</span></tt>([parameter_name,&nbsp;print_info])</td>
<td>Return value of specified input parameters.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_order</span></tt>()</td>
<td>Return the order of the current method.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_parameter_info</span></tt>([print_info])</td>
<td>Return a dictionary containing all properties of all legal parameters in current subclass (i.e., the parameters in <tt class="docutils literal"><span class="pre">self._parameters</span></tt>).</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">has_u_t_all</span></tt>()</td>
<td>Return True if self.u_all and self.t_all, defined in</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize</span></tt>()</td>
<td>Subclass-specific initialization.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize_for_solve</span></tt>()</td>
<td>Setting values of internal attributes to be used in iteration.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">set</span></tt>([strict])</td>
<td>Assign values to one or more parameters, specified as keyword arguments.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">set_initial_condition</span></tt>(U0)</td>
<td>Function set_initial_condition() is used to set initial value of</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">solve</span></tt>(time_points[,&nbsp;terminate])</td>
<td>Compute discrete solution u of the ODE problem at time points</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">switch_to</span></tt>(solver_target[,&nbsp;print_info])</td>
<td>Create a new solver instance which switch to another subclass with same values of common attributes.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">validate_data</span></tt>()</td>
<td>This function is used for extra checking and validating of attributes before the computations start.</td>
</tr>
</tbody>
</table>
<dl class="attribute">
<dt id="odespy.RungeKutta.RungeKutta3.__module__">
<tt class="descname">__module__</tt><em class="property"> = 'odespy.RungeKutta'</em><a class="headerlink" href="#odespy.RungeKutta.RungeKutta3.__module__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="odespy.RungeKutta.RungeKutta3.quick_description">
<tt class="descname">quick_description</tt><em class="property"> = 'Explicit 3rd-order Runge-Kutta method'</em><a class="headerlink" href="#odespy.RungeKutta.RungeKutta3.quick_description" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="odespy.RungeKutta.RungeKutta4">
<em class="property">class </em><tt class="descclassname">odespy.RungeKutta.</tt><tt class="descname">RungeKutta4</tt><big>(</big><em>f</em>, <em>**kwargs</em><big>)</big><a class="reference internal" href="_modules/odespy/RungeKutta.html#RungeKutta4"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#odespy.RungeKutta.RungeKutta4" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#odespy.RungeKutta.RungeKutta1level" title="odespy.RungeKutta.RungeKutta1level"><tt class="xref py py-class docutils literal"><span class="pre">odespy.RungeKutta.RungeKutta1level</span></tt></a></p>
<p>Standard Runge-Kutta method of order 4.
Implementated in the general Python framework in the RungeKutta module.</p>
<p>Required input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="7%" />
<col width="93%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f</td>
<td>Right-hand side <tt class="docutils literal"><span class="pre">f(u,t)</span></tt> defining the ODE.</td>
</tr>
</tbody>
</table>
<p>Optional input arguments:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td>f_args</td>
<td>Extra positional arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs).</span></tt> (default: ())</td>
</tr>
<tr class="row-odd"><td>f_kwargs</td>
<td>Extra keyword arguments to f: <tt class="docutils literal"><span class="pre">f(u,</span> <span class="pre">t,</span> <span class="pre">*f_args,</span>
<span class="pre">**f_kwargs)</span></tt>. (default: {})</td>
</tr>
<tr class="row-even"><td>complex_valued</td>
<td>True if f is complex valued. (default: False)</td>
</tr>
<tr class="row-odd"><td>disk_storage</td>
<td>Indicates whether u is stored in memory or in file. If
string, it is the filename; if False or &#8220;&#8221;, u is kept in
memory; if True, a default filename tmp_odspy.dat is
used. (default: False)</td>
</tr>
<tr class="row-even"><td>verbose</td>
<td>Integer reflecting output of intermediate quantities.
(default: 0)</td>
</tr>
<tr class="row-odd"><td>u_exact</td>
<td>Function of t returning exact solution. (default: None)</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">adjust_parameters</span></tt>()</td>
<td>This method allows subclasses to adjust (modify or add) entries in the self._parameters dictionary.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">advance</span></tt>()</td>
<td>Advance the solution one time step: t[n] to t[n+1].</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_conditional_parameters</span></tt>()</td>
<td>This function is used to check whether conditional parameters are provided when specified condition fulfilled.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_extra</span></tt>(**kwargs)</td>
<td>A parameter may have a keyword <tt class="docutils literal"><span class="pre">extra_check</span></tt> for user-given functions that performs consistency checks on the parameter.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_range</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are in right specified range.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">check_input_types</span></tt>(**kwargs)</td>
<td>Check whether all existing inputs are of right specified type.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">compile_string_functions</span></tt>(f,&nbsp;**kwargs)</td>
<td>Compile functions which are supplied as Fortran strings.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">constant_time_step</span></tt>()</td>
<td>Check if self.t has a uniform partition.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get</span></tt>([parameter_name,&nbsp;print_info])</td>
<td>Return value of specified input parameters.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_order</span></tt>()</td>
<td>Return the order of the current method.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">get_parameter_info</span></tt>([print_info])</td>
<td>Return a dictionary containing all properties of all legal parameters in current subclass (i.e., the parameters in <tt class="docutils literal"><span class="pre">self._parameters</span></tt>).</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">has_u_t_all</span></tt>()</td>
<td>Return True if self.u_all and self.t_all, defined in</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize</span></tt>()</td>
<td>Subclass-specific initialization.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">initialize_for_solve</span></tt>()</td>
<td>Setting values of internal attributes to be used in iteration.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">set</span></tt>([strict])</td>
<td>Assign values to one or more parameters, specified as keyword arguments.</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">set_initial_condition</span></tt>(U0)</td>
<td>Function set_initial_condition() is used to set initial value of</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">solve</span></tt>(time_points[,&nbsp;terminate])</td>
<td>Compute discrete solution u of the ODE problem at time points</td>
</tr>
<tr class="row-even"><td><tt class="xref py py-obj docutils literal"><span class="pre">switch_to</span></tt>(solver_target[,&nbsp;print_info])</td>
<td>Create a new solver instance which switch to another subclass with same values of common attributes.</td>
</tr>
<tr class="row-odd"><td><tt class="xref py py-obj docutils literal"><span class="pre">validate_data</span></tt>()</td>
<td>This function is used for extra checking and validating of attributes before the computations start.</td>
</tr>
</tbody>
</table>
<dl class="attribute">
<dt id="odespy.RungeKutta.RungeKutta4.__module__">
<tt class="descname">__module__</tt><em class="property"> = 'odespy.RungeKutta'</em><a class="headerlink" href="#odespy.RungeKutta.RungeKutta4.__module__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="odespy.RungeKutta.RungeKutta4.quick_description">
<tt class="descname">quick_description</tt><em class="property"> = 'Explicit 4th-order Runge-Kutta method'</em><a class="headerlink" href="#odespy.RungeKutta.RungeKutta4.quick_description" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

</div>


          </div>
        </div>
      </div>
      <div class="sphinxsidebar">
        <div class="sphinxsidebarwrapper">
  <h4>Previous topic</h4>
  <p class="topless"><a href="runtests.html"
                        title="previous chapter"><tt class="docutils literal"><span class="pre">odespy.runtests</span></tt></a></p>
<div id="searchbox" style="display: none">
  <h3>Quick search</h3>
    <form class="search" action="search.html" method="get">
      <input type="text" name="q" />
      <input type="submit" value="Go" />
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>
    <p class="searchtip" style="font-size: 90%">
    Enter search terms or a module, class or function name.
    </p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="np-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="runtests.html" title="odespy.runtests"
             >previous</a> |</li>
        <li><a href="index.html">Odespy API 0.2 documentation</a> &raquo;</li> 
      </ul>
    </div>
    <div class="footer">
        &copy; Copyright 2012, Liwei Wang and Hans Petter Langtangen.
      Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.2.
    </div>
  </body>
</html>